const { app, BrowserWindow, ipcMain, dialog } = require('electron');
const path = require('path');
const fs = require('fs');
const { spawn } = require('child_process');
const axios = require('axios');
const iconv = require('iconv-lite');

// 保持对window对象的全局引用，避免JavaScript对象被垃圾回收时，窗口被自动关闭
let mainWindow;
let wechatProcess = null;
let wechatRestartAttempts = 0;
const MAX_RESTART_ATTEMPTS = 5;
let wechatLoginStatus = false; // 添加微信登录状态变量
let logs = [];

// 创建主窗口
function createWindow() {
  mainWindow = new BrowserWindow({
    width: 1200,
    height: 800,
    webPreferences: {
      nodeIntegration: true,
      contextIsolation: true,
      preload: path.join(__dirname, 'preload.js'),
      sandbox: false
    }
  });

  // 加载应用
  const isDev = process.env.NODE_ENV === 'development';
  if (isDev) {
    mainWindow.loadURL('http://localhost:5173');
    // 打开开发者工具
    mainWindow.webContents.openDevTools();
  } else {
    mainWindow.loadFile(path.join(__dirname, '../../dist/index.html'));
  }

  // 当窗口关闭时触发
  mainWindow.on('closed', () => {
    mainWindow = null;
    stopWechatService();
  });
}

// 发送日志到渲染进程
function sendLog(message, isError = false) {
  console.log(`[LOG] ${message}`);
  
  if (!mainWindow) return;
  
  // 确保消息是字符串
  const logMessage = typeof message === 'object' ? JSON.stringify(message) : String(message);
  
  if (isError) {
    mainWindow.webContents.send('wechat-error', logMessage);
  } else {
    mainWindow.webContents.send('wechat-log', logMessage);
  }
}

// 启动微信服务
async function startWechatService() {
  try {
    if (isWechatServiceRunning()) {
      sendLog('微信服务已在运行中');
      return { success: true, message: '服务已在运行中' };
    }

    sendLog('正在启动微信服务...');
    
    // 重置登录状态
    wechatLoginStatus = false;
    
    // 检查是否以管理员身份运行
    try {
      // 在Windows上尝试写入一个系统受保护的位置来测试权限
      const testFile = path.join(process.env.WINDIR, 'temp', 'electron_admin_test.txt');
      try {
        fs.writeFileSync(testFile, 'test', { flag: 'w' });
        fs.unlinkSync(testFile);
        console.log('应用以管理员权限运行');
      } catch (e) {
        console.warn('应用没有以管理员权限运行，这可能会导致某些功能受限');
        const adminRequired = await dialog.showMessageBox({
          type: 'question',
          buttons: ['继续尝试', '取消'],
          title: '权限提示',
          message: 'wrest.exe可能需要管理员权限才能正常运行。',
          detail: '您希望继续尝试启动服务吗？如遇问题，请尝试以管理员身份重启应用。'
        });
        
        if (adminRequired.response === 1) {
          return false;
        }
      }
    } catch (error) {
      console.error('检查管理员权限时出错:', error);
    }
    
    // 尝试多个可能的路径查找wrest.exe
    let wechatExePath;
    const isDev = process.env.NODE_ENV === 'development';
    
    // 在开发环境中的可能路径
    const possiblePaths = [
      path.join(process.cwd(), 'wrest.exe'),
      path.join(process.cwd(), 'resources', 'wrest.exe'),
      path.join(app.getAppPath(), 'resources', 'wrest.exe')
    ];
    
    // 在生产环境中的路径
    if (!isDev) {
      possiblePaths.push(
        path.join(process.resourcesPath, 'extraResources', 'wrest.exe'),
        path.join(path.dirname(app.getPath('exe')), 'resources', 'extraResources', 'wrest.exe')
      );
    }
    
    // 查找存在的文件
    for (const testPath of possiblePaths) {
      if (fs.existsSync(testPath)) {
        wechatExePath = testPath;
        console.log('找到wrest.exe路径:', wechatExePath);
        break;
      }
    }
    
    if (!wechatExePath) {
      const errorMsg = '找不到wrest.exe文件，已尝试以下路径:\n' + possiblePaths.join('\n');
      console.error(errorMsg);
      dialog.showErrorBox('错误', errorMsg);
      return false;
    }
    
    // 获取wrest.exe所在的目录，作为工作目录
    const workingDir = path.dirname(wechatExePath);
    console.log('工作目录:', workingDir);
    console.log('启动命令:', wechatExePath);
    
    // 检查文件是否可执行
    try {
      fs.accessSync(wechatExePath, fs.constants.X_OK);
      console.log('wrest.exe具有执行权限');
    } catch (error) {
      console.warn('wrest.exe可能没有执行权限:', error.message);
      // 继续尝试运行
    }

    try {
      wechatProcess = spawn(wechatExePath, [], {
        detached: false,
        stdio: 'pipe',
        cwd: workingDir, // 设置工作目录为wrest.exe所在目录
        shell: true,     // 使用shell运行命令，可以绕过某些权限问题
        windowsHide: false
      });
      
      console.log('wrest.exe进程已启动, PID:', wechatProcess.pid);
    } catch (spawnError) {
      console.error('启动wrest.exe时出错:', spawnError);
      dialog.showErrorBox('启动失败', `无法启动wrest.exe: ${spawnError.message}`);
      return false;
    }

    wechatProcess.stdout.on('data', (data) => {
      // 使用UTF-8解码
      const output = iconv.decode(data, 'utf-8');
      sendLog(`wrest.exe 输出: ${output}`);
    });

    wechatProcess.stderr.on('data', (data) => {
      // 使用UTF-8解码
      const errorOutput = iconv.decode(data, 'utf-8');
      sendLog(`wrest.exe 错误: ${errorOutput}`, true);
    });

    // 添加错误处理
    wechatProcess.on('error', (error) => {
      sendLog(`wrest.exe 进程错误: ${error.message}`, true);
      if (mainWindow) {
        mainWindow.webContents.send('wechat-status', { running: false, error: error.message });
      }
      return false;
    });

    wechatProcess.on('close', (code) => {
      sendLog(`wrest.exe 进程退出，退出码: ${code}`);
      
      // 清理进程引用
      wechatProcess = null;
      
      // 如果主窗口存在，发送状态更新
      if (mainWindow) {
        // 使用延迟避免立即更新状态
        setTimeout(() => {
          mainWindow.webContents.send('wechat-status', { 
            running: false, 
            loggedIn: false,
            exitCode: code
          });
        }, 500);
      }
      
      // 不再尝试自动重启，由用户手动控制
    });

    // 等待服务启动
    sendLog('等待服务启动，这可能需要几秒钟...');
    return true;
    
  } catch (error) {
    console.error('启动微信服务时出错:', error);
    if (mainWindow) {
      mainWindow.webContents.send('wechat-status', { running: false, error: error.message });
    }
    return false;
  }
}

// 停止微信服务
function stopWechatService() {
  sendLog('正在停止微信服务...');
  
  // 重置登录状态
  wechatLoginStatus = false;
  
  if (wechatProcess) {
    try {
      sendLog('正在停止微信服务，PID: ' + wechatProcess.pid);
      
      // 在Windows上使用taskkill强制结束进程及其子进程
      const { execSync } = require('child_process');
      try {
        execSync(`taskkill /F /PID ${wechatProcess.pid} /T`);
        sendLog('成功使用taskkill终止进程');
      } catch (tkError) {
        sendLog('taskkill失败，尝试使用process.kill: ' + tkError.message, true);
        process.kill(wechatProcess.pid, 'SIGKILL');
      }
      
      // 额外检查进程是否还在运行
      setTimeout(() => {
        try {
          // 尝试向进程发送空信号，如果不抛出异常说明进程还在运行
          process.kill(wechatProcess.pid, 0);
          sendLog('进程似乎仍在运行，可能需要手动终止', true);
        } catch (e) {
          // 进程已终止，这是我们期望的
          sendLog('确认进程已终止');
        }
      }, 1000);
    } catch (error) {
      sendLog('停止微信服务时出错: ' + error.message, true);
    }
    wechatProcess = null;
  }
}

// 写入禁止微信自动更新的注册表配置
function disableWechatAutoUpdate() {
  try {
    const { execSync } = require('child_process');
    // 创建注册表项禁止微信自动更新
    execSync('reg add "HKCU\\Software\\Tencent\\WeChat" /v NeedUpdateType /t REG_DWORD /d 0 /f');
    console.log('已禁用微信自动更新');
    return true;
  } catch (error) {
    console.error('禁用微信自动更新时出错:', error);
    return false;
  }
}

// 检查微信服务是否运行
function isWechatServiceRunning() {
  sendLog('检查微信服务是否运行');
  if (wechatProcess && !wechatProcess.killed) {
    try {
      // 检查进程是否存在
      const exitCode = wechatProcess.exitCode;
      sendLog(`微信服务进程状态: ${exitCode === null ? '运行中' : '已退出，退出码: ' + exitCode}`);
      return exitCode === null; // 如果 exitCode 为 null，则进程还在运行
    } catch (error) {
      sendLog(`检查进程状态出错: ${error.message}`);
      return false;
    }
  } else {
    sendLog('微信服务未运行');
    return false;
  }
}

// 检查微信登录状态
async function checkWechatLoginStatus() {
  sendLog('检查微信登录状态');
  try {
    if (!isWechatServiceRunning()) {
      sendLog('微信服务未运行，无法检查登录状态');
      wechatLoginStatus = false;
      return false;
    }
    
    const data = await getWechatApi('/wcf/is_login');
    const isLoggedIn = data && data.Payload === true;
    
    sendLog(`登录状态检查结果: ${isLoggedIn ? '已登录' : '未登录'}`);
    wechatLoginStatus = isLoggedIn;
    
    return isLoggedIn;
  } catch (error) {
    sendLog(`检查登录状态出错: ${error.message}`);
    wechatLoginStatus = false;
    return false;
  }
}

// 定期检查登录状态
function startLoginStatusCheck() {
  // 每60秒检查一次登录状态
  setInterval(async () => {
    try {
      if (isWechatServiceRunning()) {
        await checkWechatLoginStatus();
      }
    } catch (error) {
      sendLog(`定时检查登录状态出错: ${error.message}`);
    }
  }, 60000);
}

// 当Electron完成初始化并准备创建浏览器窗口时调用此方法
app.whenReady().then(async () => {
  // 设置开发环境变量
  process.env.NODE_ENV = 'development';
  
  createWindow();
  
  // 禁用微信自动更新
  disableWechatAutoUpdate();
  
  // 输出使用指南并自动启动wrest.exe服务
  console.log('==============================================');
  console.log('微信消息转发助手启动成功');
  console.log('使用步骤:');
  console.log('1. 等待wrest.exe服务自动启动');
  console.log('2. 在微信上完成登录授权');
  console.log('3. 点击"我已登录"按钮确认登录状态');
  console.log('4. 登录成功后即可配置转发规则');
  console.log('==============================================');
  
  // 自动启动wrest.exe服务
  try {
    console.log('正在自动启动wrest.exe服务...');
    console.log('当前工作目录:', process.cwd());
    console.log('应用路径:', app.getAppPath());
    
    const testResult = await startWechatService();
    console.log('wrest.exe服务启动结果:', testResult);
    
    if (testResult) {
      console.log('wrest.exe服务启动成功，等待用户在微信上登录并点击"我已登录"按钮');
    } else {
      console.log('wrest.exe服务启动失败，用户可能需要手动点击"启动服务"按钮');
    }
  } catch (error) {
    console.error('自动启动wrest.exe服务时出错:', error);
  }
  
  app.on('activate', () => {
    // 在macOS上，当点击dock图标并且没有其他窗口打开时，通常在应用程序中重新创建一个窗口
    if (BrowserWindow.getAllWindows().length === 0) {
      createWindow();
    }
  });
});

// 当所有窗口关闭时退出应用
app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') {
    app.quit();
  }
});

// 在应用退出前尝试关闭微信服务
app.on('before-quit', () => {
  stopWechatService();
});

// IPC通信处理
ipcMain.handle('start-wechat-service', async () => {
  sendLog('收到启动微信服务的IPC请求');
  const result = await startWechatService();
  sendLog('微信服务启动结果: ' + (result ? '成功' : '失败'));
  return result;
});

ipcMain.handle('stop-wechat-service', () => {
  sendLog('收到停止微信服务的IPC请求');
  stopWechatService();
  return true;
});

ipcMain.handle('check-wechat-service', async () => {
  try {
    sendLog('检查微信服务状态');
    const status = {
      running: isWechatServiceRunning(),
      loggedIn: wechatLoginStatus
    };
    sendLog(`微信服务状态: ${JSON.stringify(status)}`);
    return status;
  } catch (error) {
    sendLog(`检查微信服务状态错误: ${error.message}`);
    throw error;
  }
});

// 获取微信API接口
ipcMain.handle('get-wechat-api', async (event, endpoint) => {
  try {
    sendLog(`调用 get-wechat-api: ${endpoint}`);
    const result = await getWechatApi(endpoint);
    return result;
  } catch (error) {
    sendLog(`get-wechat-api 错误: ${error.message}`);
    throw error;
  }
});

// 发送微信API请求
ipcMain.handle('post-wechat-api', async (event, endpoint, postData) => {
  try {
    sendLog(`调用 post-wechat-api: ${endpoint}`);
    const result = await postWechatApi(endpoint, postData);
    return result;
  } catch (error) {
    sendLog(`post-wechat-api 错误: ${error.message}`);
    throw error;
  }
});

// 发送API请求到wrest.exe
const postWechatApi = async (endpoint, postData = {}) => {
  const url = `http://127.0.0.1:7600${endpoint}`;
  sendLog(`API 请求准备: ${endpoint}`);
  sendLog(`请求参数: ${JSON.stringify(postData)}`);

  try {
    // 设置请求超时
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), 10000); // 10秒超时
    
    sendLog(`开始发送请求到: ${url}`);
    const response = await fetch(url, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(postData),
      signal: controller.signal
    });
    
    clearTimeout(timeoutId);
    
    sendLog(`收到 ${endpoint} 的响应状态: ${response.status}`);
    
    if (!response.ok) {
      const errorText = await response.text();
      sendLog(`API 请求失败: ${response.status} ${response.statusText} - ${errorText}`);
      throw new Error(`Request failed with status ${response.status}: ${response.statusText}`);
    }
    
    const data = await response.json();
    sendLog(`API 响应数据: ${JSON.stringify(data)}`);
    
    if (data.Code !== 0) {
      sendLog(`API 返回错误代码: ${data.Code}, 消息: ${data.Message || 'No message'}`);
    }
    
    return data;
  } catch (error) {
    if (error.name === 'AbortError') {
      sendLog(`API 请求超时: ${endpoint}`);
      throw new Error('API request timeout');
    } else if (error.code === 'ECONNREFUSED') {
      sendLog(`API 连接被拒绝: ${url} - 请确认微信服务已启动`);
      throw new Error('Connection refused - Please ensure WeChat service is running');
    } else {
      sendLog(`API 请求错误: ${error.message}`);
      throw error;
    }
  }
};

// 获取API数据 (GET请求)
const getWechatApi = async (endpoint) => {
  const url = `http://127.0.0.1:7600${endpoint}`;
  sendLog(`GET API 请求准备: ${endpoint}`);
  
  try {
    // 先检查服务是否运行
    if (!isWechatServiceRunning()) {
      sendLog(`GET API 请求失败: 微信服务未运行`);
      throw new Error('WeChat service is not running');
    }
    
    // 设置请求超时
    const controller = new AbortController();
    const timeoutId = setTimeout(() => {
      controller.abort();
      sendLog(`GET API 请求已超时: ${endpoint} (10秒)`);
    }, 10000); // 10秒超时
    
    sendLog(`开始发送GET请求到: ${url}`);
    
    // 尝试使用 axios 代替 fetch
    try {
      const response = await axios.get(url, {
        headers: {
          'Content-Type': 'application/json',
        },
        timeout: 10000,
        validateStatus: false // 允许任何状态码返回
      });
      
      clearTimeout(timeoutId);
      
      sendLog(`收到 ${endpoint} 的GET响应状态: ${response.status}`);
      
      if (response.status !== 200) {
        sendLog(`GET API 请求失败: 状态码 ${response.status} - ${JSON.stringify(response.data || {})}`);
        throw new Error(`Request failed with status ${response.status}`);
      }
      
      sendLog(`GET API 响应数据: ${JSON.stringify(response.data)}`);
      
      if (response.data && response.data.Code !== 0) {
        sendLog(`API 返回错误代码: ${response.data.Code}, 消息: ${response.data.Message || 'No message'}`);
      }
      
      return response.data;
    } catch (axiosError) {
      clearTimeout(timeoutId);
      
      if (axiosError.code === 'ECONNABORTED' || axiosError.message.includes('timeout')) {
        sendLog(`GET API 请求超时: ${endpoint}`);
        throw new Error('API request timeout');
      } else if (axiosError.code === 'ECONNREFUSED') {
        sendLog(`GET API 连接被拒绝: ${url} - 检查 wrest.exe 是否正在监听此端口`);
        throw new Error('Connection refused - Please ensure WeChat service is properly running');
      } else if (axiosError.response) {
        // 有响应但状态码不是成功
        sendLog(`GET API 服务器错误: ${axiosError.response.status} - ${JSON.stringify(axiosError.response.data || {})}`);
        throw new Error(`Server returned error: ${axiosError.response.status}`);
      } else if (axiosError.request) {
        // 请求已发送但没有收到响应
        sendLog(`GET API 无响应: 请求已发送但服务器没有响应`);
        throw new Error('No response received from server');
      } else {
        // 其他错误
        sendLog(`GET API 请求错误: ${axiosError.message}`);
        throw axiosError;
      }
    }
  } catch (error) {
    sendLog(`GET API 处理错误: ${error.message}`);
    // 重新抛出错误，确保它被上游处理
    throw error;
  }
}; 